New Instances for the Single Machine Total Weighted Tardiness Problem

Previous research in the single machine total weighted tardiness problem (SMTWTP) has led to the proposition of effective local search strategies. At least existing benchmark instances from the literature do not pose a challenge for state-of-the-art algorithms. This paper describes the proposition of two classes of novel instances for the single machine total weighted tardiness problem. In response to preceding research, they are larger, thus harder to search by local search algorithms. Besides, they are computed w. r. t. control parameters that lead to comparable difficult data sets. In addition to providing novel instances, we report best known results, which have been computed by a Variable Neighborhood Descent algorithm. 1 Problem description In the SMTWTP, a set of jobs J = {J1, . . . , Jn} needs to be processed on a single machine. Each job Jj consists of a single operation only, involving a processing time pj > 0 ∀j = 1, . . . , n. The relative importance of the jobs is expressed via a nonnegative weight wj > 0 ∀j = 1, . . . , n. Processing on the machine is only possible for a single job at a time, excluding parallel processing of jobs. Each job Jj is supposed to be finished before its due date Dj. If this is not the case, a tardiness Tj occurs, measured as Tj = max {sj + pj −Dj; 0}, where sj denotes the starting time of job j. The overall objective of the problem is to find a feasible schedule x minimizing the total weighted tardiness TWT , i. e. min TWT = ∑n j=1 wjTj . A schedule for a particular problem can be interpreted as a vector of starting times of the jobs, x = (s1, . . . , sn). We assume that processing starts at time 0, thus sj 0 ∀j = 1, . . . , n. A possible overlapping of jobs on the machine is avoided by the formulation of disjunctive side constraints: sj sk + pk ∨̇ sj + pj sk ∀j, k = 1, . . . , n, j = k. As the objective function of the single machine total weighted tardiness problem is a regular function [1], it is known that at least one active schedule exists which is also optimal. A schedule is called active if, for a given sequence of jobs, all operations are started as early as possible, thus avoiding all unnecessary in-between waiting times (delays). The problem of finding an optimal schedule may therefore be reduced to the problem of finding an optimal sequence of jobs. A given sequence is represented by a permutation π = {π1, . . . , πn} of the job indices. Each element πi in π stores the index of the job which is to be processed as the ith job in the processing sequence. The permutation of indices is then ‘decoded’ into a schedule by assigning sπ1 = 0 and computing the values of sπi = sπi−1 + pπi−1 ∀i = 2, . . . , n. Obviously, this leads to an active schedule without any waiting times between jobs.